
#libraries used
import os
import ast
import pandas as pd
import numpy as np
import igraph as ig
import matplotlib.pyplot as plt
import math
import ipywidgets as widgets
from ipywidgets import interact
from ipywidgets import interactive
import seaborn as sns
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import networkx as nx


#check if running directly from main file or indirectly from a file outside this directory
# Get the current working directory
current_directory = os.getcwd()
if current_directory.endswith('601project'):
    data = pd.read_csv("Pokemon.csv")
else:
    data = pd.read_csv("../Pokemon.csv")

# Define custom colors for each type

type_colors = {
    'Bug': 'lightgreen',
    'Dark': 'black',
    'Dragon': 'darkblue',
    'Electric': 'yellow',
    'Fairy': 'lightpink',
    'Fighting': 'red',
    'Fire': 'orange',
    'Flying': '#6D5E9C',
    'Ghost': 'purple',
    'Grass': 'green',
    'Ground': '#E2BF65',
    'Ice': '#98D8D8',
    'Normal': 'grey',
    'Poison': 'mediumvioletred',
    'Psychic': 'lightcoral',
    'Rock': 'beige',
    'Steel': 'silver',
    'Water': 'blue',
    '1':'white'
}


# Define the effectiveness data
#Attacking Type is by columns, defending type by rows
type_effectiveness_data = {
    'Attacking_Type': ['Normal', 'Fire', 'Water', 'Electric', 'Grass', 'Ice', 'Fighting', 'Poison', 'Ground',
                       'Flying', 'Psychic', 'Bug', 'Rock', 'Ghost', 'Dragon', 'Dark', 'Steel', 'Fairy'],
    'Normal': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 1.0],
    'Fire': [1.0, 0.5, 0.5, 1.0, 2.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 0.5, 1.0, 1, 1.0, 2.0, 1.0],
    'Water': [1.0, 2.0, 0.5, 1.0, 0.5, 1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0, 2.0, 1.0, 1, 1.0, 1.0, 1.0],
    'Electric': [1.0, 1.0, 2.0, 0.5, 0.5, 1.0, 1.0, 1.0, 0.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1, 1.0, 1.0, 1.0],
    'Grass': [1.0, 0.5, 2.0, 0.5, 0.5, 1.0, 1.0, 0.5, 2.0, 0.5, 1.0, 0.5, 2.0, 1.0, 1, 1.0, 0.5, 1.0],
    'Ice': [1.0, 0.5, 0.5, 1.0, 2.0, 0.5, 1.0, 1.0, 2.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 0.5, 1.0],
    'Fighting': [2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 0.5, 1.0, 0.5, 0.5, 0.5, 2.0, 0.0, 1.0, 2.0, 2.0, 0.5],
    'Poison': [1.0, 1.0, 1.0, 1.0, 0.5, 1.0, 1.0, 0.5, 0.5, 1.0, 2.0, 1.0, 0.5, 0.5, 1.0, 1.0, 0.0, 2.0],
    'Ground': [1.0, 2.0, 1.0, 2.0, 0.5, 1.0, 1.0, 2.0, 1.0, 0.0, 1.0, 0.5, 2.0, 1.0, 1.0, 1.0, 2.0, 1.0],
    'Flying': [1.0, 1.0, 1.0, 0.5, 2.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 0.5, 1.0, 1.0, 1.0, 0.5, 1.0],
    'Psychic': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 0.5, 1.0],
    'Bug': [1.0, 0.5, 1.0, 1.0, 2.0, 1.0, 0.5, 0.5, 1.0, 0.5, 2.0, 1.0, 1.0, 0.5, 1.0, 2.0, 0.5, 0.5],
    'Rock': [1.0, 2.0, 1.0, 1.0, 1.0, 2.0, 0.5, 1.0, 0.5, 2.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 0.5, 1.0],
    'Ghost': [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 0.5, 1.0, 1.0],
    'Dragon': [1.0, 0.5, 0.5, 0.5, 0.5, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 0.5, 0.0],
    'Dark': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 2.0, 1.0, 0.5, 1.0, 0.5],
    'Steel': [1.0, 0.5, 0.5, 0.5, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 0.5, 1.0, 0.5, 2.0],
    'Fairy': [1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 0.5, 2.0, 1.0, 1.0, 1.0, 0.5, 1.0, 1.0, 0.0, 2.0, 0.5, 1.0]
}
#lengths = [len(normal), len(fire), len(water), len(elec), len(grass), len(ice), len(fighting), len(poison), len(ground), len(flying), len(psychic), len(bug), len(rock), len(ghost), len(dragon), len(dark), len(steel), len(fairy)]

# Create the DataFrame
pokemon_effectiveness_df = pd.DataFrame(type_effectiveness_data).set_index('Attacking_Type').transpose()

# Display the DataFrame
#print(pokemon_effectiveness_df)
#preview dataset for type effectiveness
pokemon_effectiveness_df


def Combat_Power(attack,special_atk,defense,special_def,hp):
    total_a = attack + special_atk
    total_d = defense + special_def
    numerator = math.floor(total_a * (total_d**0.5)*(hp**0.5)*(0.667934**2)) # Taking the average level as 25 so used the cpm value for level 25
    return math.floor(max(10,numerator/10))

#https://pokemongohub.net/post/article/pokemon-go-cpm-list/
#Used the CPM Value of level 25 as thats the average level of pokemon go player.


#Add Combat Power (CP) to the data frame
data['CP'] = data.apply(lambda row: Combat_Power(row['Attack'], row['Sp. Atk'], row['Defense'], row['Sp. Def'], row['HP']), axis=1)
#Preview
data.head()


df = pd.DataFrame(data)

# Combine 'Type 1' and 'Type 2' into a single column
stacked_types = pd.concat([df['Type 1'], df['Type 2'].replace('None', '')]).dropna()

# Get the frequency of each combined type
type_frequencies = stacked_types.value_counts().reset_index(name='Frequency')
#type_frequencies.head()
#pokemon_effectiveness_df.stack()
df_type_effectiveness = pd.DataFrame(type_effectiveness_data)

# Set 'Attacking_Type' as the index
df_type_effectiveness.set_index('Attacking_Type', inplace=True)

#Transpose the dataframe because the data is structured from the perspective of the pokemon type receiving an attack,
#we want know where it has an advantage over the opposing type
df_atk_type_effectiveness = df_type_effectiveness.T


# Defense: Count the occurrences of 2 (Effective) and 0.5 (Non-Effective) for each attacking type vs. defending pokemon type by pokemon type
# Offense: add pokemon type advantage vs by same pokemon type
weakness_counts = (df_type_effectiveness.iloc[:, 1:] == 2).sum(1)
resistance_counts = (df_type_effectiveness.iloc[:, 1:] <= 0.5).sum(1)
atk_effective_counts = (df_atk_type_effectiveness == 2).sum(1)

# Combine the counts into a single DataFrame
counts_df = pd.DataFrame({
    '# of Weaknesses': weakness_counts,
    '# of Resistances': resistance_counts,
    '# of Advantages': atk_effective_counts
})

#df_type_effectiveness.loc['Fire']


# Plot the bar graph
# Custom color palette with softer shades
soft_palette = sns.color_palette(['#FF6961', '#ADD8E6', '#98FB98'])
fig, ax = plt.subplots(figsize=(10, 6))
counts_df.plot(kind='bar', ax=ax, rot=45, color=soft_palette)
ax.set_facecolor('#F0F0F0')  # Set background color to a light gray

ax.set_title('Comparison of Type Effectiveness by Pokémon Typings')
ax.set_xlabel('Pokémon Type')
ax.set_ylabel('Count')
plt.show()


# Create a directed graph
G = nx.DiGraph()

# Add edges and nodes to the graph
for attacking_type in df_type_effectiveness.index:
    for defending_type, effectiveness in df_type_effectiveness.loc[attacking_type].items():
        if effectiveness == 2.0:  # Only add edges for non-neutral effectiveness
            G.add_edge(defending_type, attacking_type, weight=effectiveness)

# Use kamada_kawai_layout for better graph layout
pos = nx.kamada_kawai_layout(G)

# Plot the network graph with adjusted figure size
plt.figure(figsize=(12, 8))
nx.draw(G, pos, with_labels=True, font_weight='bold', node_size=700, node_color='skyblue', font_size=8)
nx.draw_networkx_edge_labels(G, pos, edge_labels=nx.get_edge_attributes(G, 'weight'))

plt.title('Type Effectiveness with Advantages - Network Graph for Pokémon Typings')
plt.show()


# Create a directed graph
G = nx.DiGraph()

# Add edges and nodes to the graph
for attacking_type in df_type_effectiveness.index:
    for defending_type, effectiveness in df_type_effectiveness.loc[attacking_type].items():
        if effectiveness == 0.5:  # Only add edges for non-neutral effectiveness
            G.add_edge(defending_type, attacking_type, weight=effectiveness)

# Use kamada_kawai_layout for better graph layout
#tried another graph and it was very condense and harder to see
pos = nx.kamada_kawai_layout(G)

# Plot the network graph with adjusted figure size
plt.figure(figsize=(12, 8))
nx.draw(G, pos, with_labels=True, font_weight='bold', node_size=700, node_color='skyblue', font_size=8)
nx.draw_networkx_edge_labels(G, pos, edge_labels=nx.get_edge_attributes(G, 'weight'))

plt.title('Type Effectiveness with Resistances - Network Graph for Pokémon Typings')
plt.show()


# Create a bar chart with custom colors and borders
type_frequencies.plot(kind='bar', x='index', y='Frequency', color=[type_colors.get(type, 'gray') for type in type_frequencies['index']], edgecolor='black')
plt.ylabel('Frequency')
plt.xlabel('Type')
plt.title('All-Time Frequency of Types')
plt.legend().set_visible(False)  # This line hides the legend - we are using the colors associated to the type
plt.show()


# Assuming type_frequencies is a DataFrame with columns 'index' and 'Frequency'
fig_treemap_types = px.treemap(type_frequencies, 
                 path=['index'],
                 values='Frequency',
                 color='index',
                 color_discrete_map=type_colors,
                 title='All-Time Frequency of Types')

# Hide the legend
fig_treemap_types.update_layout(legend=dict(title=dict(text='Type'), orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1))
# Set background color for the entire figure
fig_treemap_types.update_layout(
    plot_bgcolor='rgb(240,240,240)',  # Background color of the plot area
    paper_bgcolor='rgb(240,240,240)'  # Background color of the entire figure
)
# Show the treemap with border
fig_treemap_types.show()


# Combine 'Type 1' and 'Type 2' into a single column
stacked_types = pd.concat([df['Type 1'], df['Type 2'].replace('None', '')])

# Create a DataFrame with the stacked types and count frequencies
type_counts = stacked_types.value_counts()


# Give me a dataset of each Generation and Types introduced
# Create DataFrames for 'Type 1' and 'Type 2' with 'Generation' column
df_type1 = df[['Type 1', 'Generation']].rename(columns={'Type 1': 'Type'})
df_type2 = df[['Type 2', 'Generation']].rename(columns={'Type 2': 'Type'})

# Concatenate the two DataFrames
stacked_types_generation = pd.concat([df_type1, df_type2.replace('None', '')])

# Calculate the frequency of each combination of 'Generation' and 'Type'
frequency_df = stacked_types_generation.groupby(['Generation', 'Type']).size().reset_index(name='Frequency')

# Pivot the DataFrame to have 'Type' as columns
pivot_df = frequency_df.pivot(index='Generation', columns='Type', values='Frequency').fillna(0)

# Display the result
#print(stacked_types_generation)


# Create a stacked bar chart with custom colors
pivot_df.plot(kind='bar', stacked=True, figsize=(10, 6),edgecolor="black", linestyle='dashed', linewidth=0.5, color=[type_colors.get(type, 'gray') for type in pivot_df.columns])

plt.title('Stacked Bar Chart by Generation and Type')
plt.xlabel('Generation')
plt.ylabel('Frequency')
plt.xticks(rotation=45)
# Specify the legend outside the chart
plt.legend(title='Type', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.show()


# Normalize the data to represent percentages
pivot_df_percentage = pivot_df.div(pivot_df.sum(axis=1), axis=0) * 100

# Create a stacked bar chart with custom colors
ax = pivot_df_percentage.plot(kind='bar', stacked=True, figsize=(10, 6), color=[type_colors.get(type, 'gray') for type in pivot_df_percentage.columns], linestyle='dashed', linewidth=0.5, edgecolor='black')

plt.title('Stacked (Fill) Bar Chart by Generation and Type')
plt.xlabel('Generation')
plt.ylabel('Percentage')
plt.xticks(rotation=45)

# Add a legend
plt.legend(title='Type', bbox_to_anchor=(1.05, 1), loc='upper left')

plt.show()


# Assuming stacked_types_generation is your DataFrame
df_count = stacked_types_generation.groupby(['Generation', 'Type']).size().reset_index(name='Count')

# Loop through each generation and create a treemap
for gen in df_count['Generation'].unique():
    # Filter the DataFrame for the current generation
    df_filtered = df_count[df_count['Generation'] == gen]

    # Create a treemap for the current generation
    fig = px.treemap(df_filtered,
                     path=['Generation', 'Type'],
                     values='Count',
                     title=f'Treemap of Types for Generation {gen}',
                     color='Type',
                     color_discrete_map=type_colors)

    # Show the figure
    fig.show()


# Group data by Generation and Type
df_count = stacked_types_generation.groupby(['Generation', 'Type']).size().reset_index(name='Count')

# Sort the DataFrame by Generation and Type
df_count = df_count.sort_values(['Generation', 'Type'])

# Create an initial row for Generation 1 with variance 0 for each Type
initial_row = pd.DataFrame({'Generation': [1] * len(df_count['Type'].unique()), 'Type': df_count['Type'].unique(), 'Count': 0, 'Variance': 0})

# Concatenate the initial row with the original DataFrame
df_count = pd.concat([initial_row, df_count])

# Calculate the variance between consecutive generations
df_count['Variance'] = df_count.groupby('Type')['Count'].diff()
# Drop rows with NaN values (resulting from the diff operation)
df_count = df_count.dropna()

# Update Variance to 0 for rows where Generation is '1'
#df_count.loc[df_count['Generation'] == 1, 'Variance'] = 0

# Debugging
#df_count[df_count['Type'] == 'Water']


# Debugging window
#selected_type = 'Water'

# Filter the data for the selected Type
#selected_type_data = df_count[df_count['Type'] == selected_type]


#df_waterfall =selected_type_data
#df_waterfall


# Get unique types from df_count
unique_types = df_count['Type'].unique()

# Create a waterfall chart for each type
for selected_type in unique_types:
    # Filter the data for the selected Type
    selected_type_data = df_count[df_count['Type'] == selected_type]
    
    # Get the color for the selected type from type_colors, default gray if not found (just in case)
    type_color = type_colors.get(selected_type, 'gray')
    
    # Create a waterfall chart
    fig = go.Figure(go.Waterfall(
        name=selected_type,
        orientation="v",
        measure=selected_type_data['Variance'],
        x=selected_type_data['Generation'],
        textposition="outside",
        text=selected_type_data.apply(lambda row: f"Count: {int(row['Count'])}<br>Variance: {int(row['Variance'])}" if row['Variance'] != 0 else f"Count: {int(row['Count'])}",
                                axis=1),
        y=selected_type_data['Variance'],
        connector={"line": {"color": "rgb(63, 63, 63)"}},
        increasing=dict(marker=dict(color=type_color, line=dict(color='black', width=1))),
        decreasing=dict(marker=dict(color='darkred', line=dict(color='black', width=1))),
    ))

    # Update layout
    fig.update_layout(
        title=f"Waterfall Chart for {selected_type} - variance over Generations",
        showlegend=True,
        xaxis_title="Generation",
        yaxis_title="Count",
        paper_bgcolor='rgba(0, 0, 0, 0)',  # Set background color
        plot_bgcolor='rgba(0, 0, 0, 0)',  # Set plot area color
        height=900  # Set the desired height in pixels
    )

    # Show the figure
    fig.show()


#Create a new dataframe to begin next set of analyses so there is no conflict
pokemon_df = data.copy()
# Classify Pokémon as 'Single-Type' or 'Dual-Type'
pokemon_df['Type Count'] = pokemon_df['Type 2'].apply(lambda x: 'Dual-Type' if pd.notnull(x) else 'Single-Type')

# Classify Pokémon as 'Single-Type' or 'Dual-Type'
pokemon_df['Type Count'] = pokemon_df['Type 2'].apply(lambda x: 'Dual-Type' if pd.notnull(x) else 'Single-Type')

# Mean Calculation
numeric_cols = pokemon_df.select_dtypes(include=['float64', 'int64']).columns.drop('Generation')

# Calculate average stats for Single-Type and Dual-Type Pokémon
avg_stats_by_type = pokemon_df.groupby('Type Count')[numeric_cols].mean()
#debugging line
#avg_stats_by_type


# Plot
# Define columns to exclude, only want the attributes
exclude_columns = ['CP', 'Evolution']
included_attribute_columns = [col for col in avg_stats_by_type.columns if col not in exclude_columns]
# Create a color palette
palette = sns.color_palette("tab10", n_colors=len(included_attribute_columns))

plt.figure(figsize=(14, 8))

for stat, color in zip(included_attribute_columns, palette):
    sns.barplot(x=avg_stats_by_type.index, y=avg_stats_by_type[stat], label=stat, color=color)

plt.title('Average Stats for Single-Type vs Dual-Type Pokémon')
plt.ylabel('Average Stat Value')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()


numeric_stats = pokemon_df.select_dtypes(include=[np.number]).drop(columns=['Generation'])

# Mean of numeric attributes for each generation
avg_stats_by_gen = pokemon_df.groupby('Generation')[numeric_stats.columns].mean().reset_index()

# Moving average with a window of 2 generations for smoothing
for stat in numeric_stats.columns:
    column_name = f'{stat}_MA'
    avg_stats_by_gen[column_name] = avg_stats_by_gen[stat].rolling(window=2).mean()

# Focusing on moving averages
melted_stats_ma = pd.melt(avg_stats_by_gen, id_vars=["Generation"], 
                          value_vars=[f'{stat}_MA' for stat in numeric_stats.columns], 
                          var_name='Stat', value_name='Moving Average')

melted_stats_ma['Stat'] = melted_stats_ma['Stat'].str.replace('_MA', '')

# Visualization
g = sns.FacetGrid(melted_stats_ma, col="Stat", col_wrap=3, height=4, sharex=False, sharey=False)
g = g.map(plt.plot, "Generation", "Moving Average", marker=".")
g.set_titles("{col_name}")
g.set_axis_labels("Generation", "Moving Average")
plt.subplots_adjust(top=0.9)
g.fig.suptitle('Moving Average of Pokémon Stats by Generation', fontsize=16)
plt.show()

C:\Users\notso\anaconda3\Lib\site-packages\seaborn\axisgrid.py:118: UserWarning:

The figure layout has changed to tight


# Convert columns that should be numeric but are stored as objects
numeric_cols = ['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed'] 

for col in numeric_cols:
    pokemon_df[col] = pd.to_numeric(pokemon_df[col], errors='coerce')  # 'coerce' will set invalid parsing as NaN

# Mean of each attribute for each generation
avg_stats_by_gen = pokemon_df.groupby('Generation')[numeric_cols].mean()

# Single plot for comparison
plt.figure(figsize=(12, 8))

for col in numeric_cols:
    sns.lineplot(data=avg_stats_by_gen, x=avg_stats_by_gen.index, y=col, label=col)

plt.title('Average Pokémon Stats by Generation')
plt.xlabel('Generation')
plt.ylabel('Average Stat Value')
plt.legend(title='Stats')
plt.show()


#Create a new dataframe to begin next set of analyses so there is no conflict
pokemon_df = data.copy()
# Identify Legendary Pokémon and calculate proportions per type
# Consider both Type 1 and Type 2
type_1_legendary = pokemon_df.groupby('Type 1')['Legendary'].value_counts(normalize=True).unstack().fillna(0)[True]
type_2_legendary = pokemon_df.groupby('Type 2')['Legendary'].value_counts(normalize=True).unstack().fillna(0)[True]
legendary_proportions = (type_1_legendary.add(type_2_legendary, fill_value=0) / 2).sort_values(ascending=False)

# Visualization
plt.figure(figsize=(10, 12))  # Adjusted figure size for better readability
sns.barplot(x=legendary_proportions, y=legendary_proportions.index, palette=type_colors,edgecolor="black")
plt.title('Proportion of Legendary Pokémon by Type', fontsize=16)
plt.xlabel('Proportion of Legendary', fontsize=14)
plt.ylabel('Type', fontsize=14)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)

plt.show()


# Create a figure with subplots
fig, axes = plt.subplots(nrows=4, ncols=2, figsize=(12, 12))
# Define the order for the 'Legendary' variable
legendary_order = [True, False]
# Define Pokemon-themed color palette
pokemon_palette = {
    True: '#FFD700',  # Gold for Legendary
    False: '#A8A878'  # Grayish color for Non-Legendary
}
# Boxplot for CP
sns.boxplot(x='Legendary', y='CP', data=data, ax=axes[0, 0], order=legendary_order, palette=pokemon_palette)
axes[0, 0].set_title('Comparison of Combat Power for Legendary and Non-Legendary Pokémon')

# Boxplot for Total
sns.boxplot(x='Legendary', y='Total', data=data, ax=axes[0, 1], order=legendary_order, palette=pokemon_palette)
axes[0, 1].set_title('Comparison of Total for Legendary and Non-Legendary Pokémon')

# Boxplot for Attack
sns.boxplot(x='Legendary', y='Attack', data=data, ax=axes[1, 0], order=legendary_order, palette=pokemon_palette)
axes[1, 0].set_title('Comparison of Attack for Legendary and Non-Legendary Pokémon')

# Boxplot for Defense
sns.boxplot(x='Legendary', y='Defense', data=data, ax=axes[1, 1], order=legendary_order, palette=pokemon_palette)
axes[1, 1].set_title('Comparison of Defense for Legendary and Non-Legendary Pokémon')

# Boxplot for HP
sns.boxplot(x='Legendary', y='HP', data=data, ax=axes[2, 0], order=legendary_order, palette=pokemon_palette)
axes[2, 0].set_title('Comparison of HP for Legendary and Non-Legendary Pokémon')

# Boxplot for Speed
sns.boxplot(x='Legendary', y='Speed', data=data, ax=axes[2, 1], order=legendary_order, palette=pokemon_palette)
axes[2, 1].set_title('Comparison of Speed for Legendary and Non-Legendary Pokémon')

# Boxplot for Sp. Atk
sns.boxplot(x='Legendary', y='Sp. Atk', data=data, ax=axes[3, 0], order=legendary_order, palette=pokemon_palette)
axes[3, 0].set_title('Comparison of Sp. Atk for Legendary and Non-Legendary Pokémon')

# Boxplot for Sp. Def
sns.boxplot(x='Legendary', y='Sp. Def', data=data, ax=axes[3, 1], order=legendary_order, palette=pokemon_palette)
axes[3, 1].set_title('Comparison of Sp. Def for Legendary and Non-Legendary Pokémon')

# Adjust layout
plt.tight_layout()
plt.show()


average_total_by_type = data.groupby(['Type 1'])['Total'].mean().reset_index()

adjacency_matrix = pd.DataFrame(type_effectiveness_data).set_index('Attacking_Type')

average_effectiveness_by_type = adjacency_matrix.mean(axis=1).reset_index()
average_effectiveness_by_type.columns = ['Type', 'Average_Effectiveness']

merged_df = pd.merge(average_total_by_type, average_effectiveness_by_type, left_on='Type 1', right_on='Type')
correlation = merged_df['Total'].corr(merged_df['Average_Effectiveness'])

plt.figure(figsize=(10, 6))
sns.scatterplot(x='Average_Effectiveness', y='Total', data=merged_df, hue='Type', palette=type_colors, edgecolor="black")
plt.title('Correlation between Average Effectiveness and Total Attribute')
plt.xlabel('Average Effectiveness')
plt.ylabel('Average Total Attribute')
plt.show()

print(f'Correlation between Average Effectiveness and Total Attribute: {correlation}')

Correlation between Average Effectiveness and Total Attribute: -0.06155481397688639


def update_plot(type_selected):
    filtered_data = data[
        (data['Type 1'] == type_selected) | (data['Type 2'] == type_selected)
    ]

    if not filtered_data.empty:
        plt.figure(figsize=(12, 8))
        sns.kdeplot(x='CP', hue='Generation', data=filtered_data, fill=True, common_norm=False)
        plt.title(f'Ridge Plot of CP for {type_selected} Type Pokémon')
        plt.xlabel('CP')
        plt.ylabel('Density')
        plt.grid(True)
        plt.show()
    else:
        print('No Pokemon available for the selected type.')

all_types = pd.concat([data['Type 1'], data['Type 2']]).unique()

type_dropdown = widgets.Dropdown(options=['All'] + list(all_types), value='All', description='Select Type:')

interactive_plot = interactive(
    update_plot,
    type_selected=type_dropdown,
)

display(interactive_plot)


all_types = ['All'] + data['Type 1'].unique().tolist()

type_dropdown = widgets.Dropdown(options=all_types, value='All', description='Select Type:')

def update_radar_chart(selected_type):
    if selected_type == 'All':
        filtered_data = data
    else:
        filtered_data = data[data['Type 1'] == selected_type]

    radar_data = []
    for _, row in filtered_data.iterrows():
        radar_data.append(go.Scatterpolar(
            r=row[['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed', 'HP']].tolist(),
            theta=['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed', 'HP'],
            fill='toself',
            name=row['Name']
        ))

    layout = go.Layout(
        polar=dict(
            radialaxis=dict(
                visible=True,
                range=[0, 250]
            )
        ),
        showlegend=True,
        title="Stats for {} Type Pokémon".format(selected_type)
    )

    fig = go.Figure(data=radar_data, layout=layout)
    fig.update_layout(barmode='stack')
    fig.show()


interactive_radar_chart = interact(update_radar_chart, selected_type=type_dropdown)
display(interactive_radar_chart)
# Double click the pokemon on the sidebar to isolate specific pokemons and compare with other pokemons of same type.

<function __main__.update_radar_chart(selected_type)>


type1_dropdown = widgets.Dropdown(options=['All'] + data['Type 1'].unique().tolist(), value='All', description='Select Type 1:')
type2_dropdown = widgets.Dropdown(options=['All'] + data['Type 2'].dropna().unique().tolist(), value='All', description='Select Type 2:')
cp_slider = widgets.IntSlider(min=data['CP'].min(), max=data['CP'].max(), step=10, value=data['CP'].min(), description='Combat Power:')

def filter_pokemon(selected_type1, selected_type2, selected_cp):
    if selected_type1 == 'All' and selected_type2 == 'All':
        filtered_data = data[data['CP'] >= selected_cp]
    elif selected_type1 == 'All':
        filtered_data = data[((data['Type 2'] == selected_type2) | (data['Type 2'].isnull())) & (data['CP'] >= selected_cp)]
    elif selected_type2 == 'All':
        filtered_data = data[(data['Type 1'] == selected_type1) & (data['CP'] >= selected_cp)]
    else:
        filtered_data = data[((data['Type 1'] == selected_type1) & (data['Type 2'] == selected_type2)) & (data['CP'] >= selected_cp)]
    
    display(filtered_data)


interactive_df = interact(filter_pokemon, selected_type1=type1_dropdown, selected_type2=type2_dropdown, selected_cp=cp_slider)
display(interactive_df)

What is the distribution of Pokémon types?¶

Visualizing the Relationships between Pokémon Types with Network Graphs¶

Analyzing the Distribution of Pokémon Types Across Generations 1-6 with Stacked Charts and Treemaps¶

In-Depth Pokémon Type Distribution Analysis with Bar Graphs and Treemaps¶

Analyzing Distribution Variances Across Generations with Waterfall Charts¶

Are there noticeable patterns or advantages in having dual types compared to single-types Pokémon?¶

How have the attributes of Pokémon evolved acquired across different generations?¶

Are there specific types that are more likely to be associated with legendary Pokémon?¶

How do legendary Pokémon compare to non-legendary Pokémon in terms of overall strength and individual attributes?¶

Comparative Analysis: Legendary vs. Non-Legendary Pokémon Strength and Attributes with Boxplots¶

Combat Power, Total Attribute and Type for Battle Effectiveness¶

How do different types of Pokémon correlate with their overall strength, as indicated by the 'Total' attribute?¶

What insights can be gained from analyzing the relationship between specific attributes (e.g., Attack, Defense, Speed) and a Pokémon's effectiveness in battles?¶

Next Steps¶

References¶

Attacking_Type	Normal	Fire	Water	Electric	Grass	Ice	Fighting	Poison	Ground	Flying	Psychic	Bug	Rock	Ghost	Dragon	Dark	Steel	Fairy
Normal	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	0.5	0.0	1.0	1.0	0.5	1.0
Fire	1.0	0.5	0.5	1.0	2.0	2.0	1.0	1.0	1.0	1.0	1.0	2.0	0.5	1.0	1.0	1.0	2.0	1.0
Water	1.0	2.0	0.5	1.0	0.5	1.0	1.0	1.0	2.0	1.0	1.0	1.0	2.0	1.0	1.0	1.0	1.0	1.0
Electric	1.0	1.0	2.0	0.5	0.5	1.0	1.0	1.0	0.0	2.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0
Grass	1.0	0.5	2.0	0.5	0.5	1.0	1.0	0.5	2.0	0.5	1.0	0.5	2.0	1.0	1.0	1.0	0.5	1.0
Ice	1.0	0.5	0.5	1.0	2.0	0.5	1.0	1.0	2.0	2.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	1.0
Fighting	2.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	1.0	0.5	0.5	0.5	2.0	0.0	1.0	2.0	2.0	0.5
Poison	1.0	1.0	1.0	1.0	0.5	1.0	1.0	0.5	0.5	1.0	2.0	1.0	0.5	0.5	1.0	1.0	0.0	2.0
Ground	1.0	2.0	1.0	2.0	0.5	1.0	1.0	2.0	1.0	0.0	1.0	0.5	2.0	1.0	1.0	1.0	2.0	1.0
Flying	1.0	1.0	1.0	0.5	2.0	1.0	2.0	1.0	1.0	1.0	1.0	2.0	0.5	1.0	1.0	1.0	0.5	1.0
Psychic	1.0	1.0	1.0	1.0	1.0	1.0	2.0	2.0	1.0	1.0	0.5	1.0	1.0	1.0	1.0	0.0	0.5	1.0
Bug	1.0	0.5	1.0	1.0	2.0	1.0	0.5	0.5	1.0	0.5	2.0	1.0	1.0	0.5	1.0	2.0	0.5	0.5
Rock	1.0	2.0	1.0	1.0	1.0	2.0	0.5	1.0	0.5	2.0	1.0	2.0	1.0	1.0	1.0	1.0	0.5	1.0
Ghost	0.0	1.0	1.0	1.0	1.0	1.0	0.0	0.5	1.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	1.0	1.0
Dragon	1.0	0.5	0.5	0.5	0.5	2.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	0.0
Dark	1.0	1.0	1.0	1.0	1.0	1.0	0.5	1.0	1.0	1.0	2.0	1.0	1.0	2.0	1.0	0.5	1.0	0.5
Steel	1.0	0.5	0.5	0.5	1.0	2.0	1.0	1.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	1.0	0.5	2.0
Fairy	1.0	0.5	1.0	1.0	1.0	1.0	0.5	2.0	1.0	1.0	1.0	0.5	1.0	1.0	0.0	2.0	0.5	1.0

	#	Name	Type 1	Type 2	Total	HP	Attack	Defense	Sp. Atk	Sp. Def	Speed	Generation	Legendary	CP
0	1	Bulbasaur	Grass	Poison	318	45	49	49	65	65	45	1	False	364
1	2	Ivysaur	Grass	Poison	405	60	62	63	80	80	60	1	False	586
2	3	Venusaur	Grass	Poison	525	80	82	83	100	100	80	1	False	982
3	3	VenusaurMega Venusaur	Grass	Poison	625	80	100	123	122	120	80	1	False	1380
4	4	Charmander	Fire	NaN	309	39	52	43	60	50	65	1	False	300